MQTTAsync.h

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2009, 2018 IBM Corp.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Eclipse Distribution License v1.0 which accompany this distribution.
 *
 * The Eclipse Public License is available at
 *    http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 *   http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *    Ian Craggs - initial API and implementation
 *    Ian Craggs, Allan Stockdill-Mander - SSL connections
 *    Ian Craggs - multiple server connection support
 *    Ian Craggs - MQTT 3.1.1 support
 *    Ian Craggs - fix for bug 444103 - success/failure callbacks not invoked
 *    Ian Craggs - automatic reconnect and offline buffering (send while disconnected)
 *    Ian Craggs - binary will message
 *    Ian Craggs - binary password
 *    Ian Craggs - remove const on eyecatchers #168
 *******************************************************************************/
 
/********************************************************************/
 
/*
*/
#if defined(__cplusplus)
 extern "C" {
#endif
 
#if !defined(MQTTASYNC_H)
#define MQTTASYNC_H
 
#if defined(WIN32) || defined(WIN64)
  #define DLLImport __declspec(dllimport)
  #define DLLExport __declspec(dllexport)
#else
  #define DLLImport extern
  #define DLLExport  __attribute__ ((visibility ("default")))
#endif
 
#include <stdio.h>
/*
*/
 
#if !defined(NO_PERSISTENCE)
#include "MQTTClientPersistence.h"
#endif
 
#define MQTTASYNC_SUCCESS 0
#define MQTTASYNC_FAILURE -1
 
/* error code -2 is MQTTAsync_PERSISTENCE_ERROR */
 
#define MQTTASYNC_PERSISTENCE_ERROR -2
 
#define MQTTASYNC_DISCONNECTED -3
#define MQTTASYNC_MAX_MESSAGES_INFLIGHT -4
#define MQTTASYNC_BAD_UTF8_STRING -5
#define MQTTASYNC_NULL_PARAMETER -6
#define MQTTASYNC_TOPICNAME_TRUNCATED -7
#define MQTTASYNC_BAD_STRUCTURE -8
#define MQTTASYNC_BAD_QOS -9
#define MQTTASYNC_NO_MORE_MSGIDS -10
#define MQTTASYNC_OPERATION_INCOMPLETE -11
#define MQTTASYNC_MAX_BUFFERED_MESSAGES -12
#define MQTTASYNC_SSL_NOT_SUPPORTED -13
#define MQTTASYNC_BAD_PROTOCOL -14
 
 
#define MQTTVERSION_DEFAULT 0
#define MQTTVERSION_3_1 3
#define MQTTVERSION_3_1_1 4
#define MQTT_BAD_SUBSCRIBE 0x80
 
 
typedef struct
{
        char struct_id[4];
        int struct_version;
        int do_openssl_init;
} MQTTAsync_init_options;
 
#define MQTTAsync_init_options_initializer { {'M', 'Q', 'T', 'G'}, 0, 0 }
 
DLLExport void MQTTAsync_global_init(MQTTAsync_init_options* inits);
 
typedef void* MQTTAsync;
typedef int MQTTAsync_token;
 
typedef struct
{
        char struct_id[4];
        int struct_version;
        int payloadlen;
        void* payload;
        int qos;
        int retained;
        int dup;
        int msgid;
} MQTTAsync_message;
 
#define MQTTAsync_message_initializer { {'M', 'Q', 'T', 'M'}, 0, 0, NULL, 0, 0, 0, 0 }
 
typedef int MQTTAsync_messageArrived(void* context, char* topicName, int topicLen, MQTTAsync_message* message);
 
typedef void MQTTAsync_deliveryComplete(void* context, MQTTAsync_token token);
 
typedef void MQTTAsync_connectionLost(void* context, char* cause);
 
 
typedef void MQTTAsync_connected(void* context, char* cause);
 
 
 
typedef struct
{
        MQTTAsync_token token;
        int code;
        const char *message;
} MQTTAsync_failureData;
 
typedef struct
{
        MQTTAsync_token token;
        union
        {
                int qos;
                int* qosList;
                struct
                {
                        MQTTAsync_message message;
                        char* destinationName;
                } pub;
                /* For connect, the server connected to, MQTT version used, and sessionPresent flag */
                struct
                {
                        char* serverURI;
                        int MQTTVersion;
                        int sessionPresent;
                } connect;
        } alt;
} MQTTAsync_successData;
 
typedef void MQTTAsync_onSuccess(void* context, MQTTAsync_successData* response);
 
typedef void MQTTAsync_onFailure(void* context,  MQTTAsync_failureData* response);
 
typedef struct
{
        char struct_id[4];
        int struct_version;
        MQTTAsync_onSuccess* onSuccess;
        MQTTAsync_onFailure* onFailure;
        void* context;
        MQTTAsync_token token;
} MQTTAsync_responseOptions;
 
#define MQTTAsync_responseOptions_initializer { {'M', 'Q', 'T', 'R'}, 0, NULL, NULL, 0, 0 }
 
 
DLLExport int MQTTAsync_setCallbacks(MQTTAsync handle, void* context, MQTTAsync_connectionLost* cl,
                                                                        MQTTAsync_messageArrived* ma, MQTTAsync_deliveryComplete* dc);
 
 
DLLExport int MQTTAsync_setConnected(MQTTAsync handle, void* context, MQTTAsync_connected* co);
 
 
DLLExport int MQTTAsync_reconnect(MQTTAsync handle);
 
 
DLLExport int MQTTAsync_create(MQTTAsync* handle, const char* serverURI, const char* clientId,
                int persistence_type, void* persistence_context);
 
typedef struct
{
        char struct_id[4];
        int struct_version;
        int sendWhileDisconnected;
        int maxBufferedMessages;
} MQTTAsync_createOptions;
 
#define MQTTAsync_createOptions_initializer { {'M', 'Q', 'C', 'O'}, 0, 0, 100 }
 
 
DLLExport int MQTTAsync_createWithOptions(MQTTAsync* handle, const char* serverURI, const char* clientId,
                int persistence_type, void* persistence_context, MQTTAsync_createOptions* options);
 
typedef struct
{
        char struct_id[4];
        int struct_version;
        const char* topicName;
        const char* message;
        int retained;
        int qos;
        struct
        {
        int len;            
                const void* data;  
        } payload;
} MQTTAsync_willOptions;
 
#define MQTTAsync_willOptions_initializer { {'M', 'Q', 'T', 'W'}, 1, NULL, NULL, 0, 0, { 0, NULL } }
 
#define MQTT_SSL_VERSION_DEFAULT 0
#define MQTT_SSL_VERSION_TLS_1_0 1
#define MQTT_SSL_VERSION_TLS_1_1 2
#define MQTT_SSL_VERSION_TLS_1_2 3
 
typedef struct
{
        char struct_id[4];
        int struct_version;
 
        const char* trustStore;
 
        const char* keyStore;
 
        const char* privateKey;
        const char* privateKeyPassword;
 
        const char* enabledCipherSuites;
 
    int enableServerCertAuth;
 
    int sslVersion;
 
    int verify;
 
        const char* CApath;
} MQTTAsync_SSLOptions;
 
#define MQTTAsync_SSLOptions_initializer { {'M', 'Q', 'T', 'S'}, 2, NULL, NULL, NULL, NULL, NULL, 1, MQTT_SSL_VERSION_DEFAULT, 0, NULL }
 
typedef struct
{
        char struct_id[4];
        int struct_version;
        int keepAliveInterval;
        int cleansession;
        int maxInflight;
        MQTTAsync_willOptions* will;
        const char* username;
        const char* password;
        int connectTimeout;
        int retryInterval;
        MQTTAsync_SSLOptions* ssl;
        MQTTAsync_onSuccess* onSuccess;
        MQTTAsync_onFailure* onFailure;
        void* context;
        int serverURIcount;
        char* const* serverURIs;
        int MQTTVersion;
        int automaticReconnect;
        int minRetryInterval;
        int maxRetryInterval;
  struct {
        int len;            
                const void* data;  
        } binarypwd;
} MQTTAsync_connectOptions;
 
 
#define MQTTAsync_connectOptions_initializer { {'M', 'Q', 'T', 'C'}, 5, 60, 1, 10, NULL, NULL, NULL, 30, 0,\
NULL, NULL, NULL, NULL, 0, NULL, 0, 0, 1, 60, {0, NULL}}
 
DLLExport int MQTTAsync_connect(MQTTAsync handle, const MQTTAsync_connectOptions* options);
 
 
typedef struct
{
        char struct_id[4];
        int struct_version;
        int timeout;
        MQTTAsync_onSuccess* onSuccess;
        MQTTAsync_onFailure* onFailure;
        void* context;
} MQTTAsync_disconnectOptions;
 
#define MQTTAsync_disconnectOptions_initializer { {'M', 'Q', 'T', 'D'}, 0, 0, NULL, NULL, NULL }
 
 
DLLExport int MQTTAsync_disconnect(MQTTAsync handle, const MQTTAsync_disconnectOptions* options);
 
 
DLLExport int MQTTAsync_isConnected(MQTTAsync handle);
 
 
DLLExport int MQTTAsync_subscribe(MQTTAsync handle, const char* topic, int qos, MQTTAsync_responseOptions* response);
 
 
DLLExport int MQTTAsync_subscribeMany(MQTTAsync handle, int count, char* const* topic, int* qos, MQTTAsync_responseOptions* response);
 
DLLExport int MQTTAsync_unsubscribe(MQTTAsync handle, const char* topic, MQTTAsync_responseOptions* response);
 
DLLExport int MQTTAsync_unsubscribeMany(MQTTAsync handle, int count, char* const* topic, MQTTAsync_responseOptions* response);
 
 
DLLExport int MQTTAsync_send(MQTTAsync handle, const char* destinationName, int payloadlen, void* payload, int qos, int retained,
                                                                                                                                 MQTTAsync_responseOptions* response);
 
 
DLLExport int MQTTAsync_sendMessage(MQTTAsync handle, const char* destinationName, const MQTTAsync_message* msg, MQTTAsync_responseOptions* response);
 
 
DLLExport int MQTTAsync_getPendingTokens(MQTTAsync handle, MQTTAsync_token **tokens);
 
#define MQTTASYNC_TRUE 1
DLLExport int MQTTAsync_isComplete(MQTTAsync handle, MQTTAsync_token token);
 
 
DLLExport int MQTTAsync_waitForCompletion(MQTTAsync handle, MQTTAsync_token token, unsigned long timeout);
 
 
DLLExport void MQTTAsync_freeMessage(MQTTAsync_message** msg);
 
DLLExport void MQTTAsync_free(void* ptr);
 
DLLExport void MQTTAsync_destroy(MQTTAsync* handle);
 
 
 
enum MQTTASYNC_TRACE_LEVELS
{
        MQTTASYNC_TRACE_MAXIMUM = 1,
        MQTTASYNC_TRACE_MEDIUM,
        MQTTASYNC_TRACE_MINIMUM,
        MQTTASYNC_TRACE_PROTOCOL,
        MQTTASYNC_TRACE_ERROR,
        MQTTASYNC_TRACE_SEVERE,
        MQTTASYNC_TRACE_FATAL,
};
 
 
DLLExport void MQTTAsync_setTraceLevel(enum MQTTASYNC_TRACE_LEVELS level);
 
 
typedef void MQTTAsync_traceCallback(enum MQTTASYNC_TRACE_LEVELS level, char* message);
 
DLLExport void MQTTAsync_setTraceCallback(MQTTAsync_traceCallback* callback);
 
 
typedef struct
{
        const char* name;
        const char* value;
} MQTTAsync_nameValue;
 
DLLExport MQTTAsync_nameValue* MQTTAsync_getVersionInfo(void);
 
 
#endif
 
#ifdef __cplusplus
     }
#endif